home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Precision Software Appli…tions Silver Collection 1
/
Precision Software Applications Silver Collection Volume One (PSM) (1993).iso
/
tutor
/
modula12.exe
/
INTRO.TXT
< prev
next >
Wrap
Text File
|
1988-10-26
|
12KB
|
257 lines
Introduction to the Modula-2 Tutorial
Welcome to the programming language Modula-2, a very
complete, high level language with many advanced features.
Modula-2 was designed by Niklaus Wirth, the designer of
Pascal. Based on experience with Pascal, Modula-2 was
designed to make up for many of the deficiencies noted by
programmers worldwide, and the changes make it a very
powerful language with few limitations. In spite of its
power, Modula-2 retains the simplicity of Pascal and can be
used for small applications as easy as Pascal could be used.
MODULA-2 TUTORIAL - PART I
Even though there are many similarities between the two
languages, the differences are significant. This tutorial
was written considering both the similarities and the
differences between the languages. The first part of this
tutorial is composed of those features that are common to
Pascal and Modula-2 and are also of a fundamental nature.
You will need to study all of Part I in order to write
meaningful Modula-2 programs. If you are already a fairly
experienced Pascal programmer, you will absorb this material
very fast. Be sure to go through it all at least once
because there are many small differences between the
languages that you must consider.
MODULA-2 TUTORIAL - PART II
The topics taught in Part II of this tutorial are those
advanced features that are also available in Pascal. Some of
these topics are pointers, dynamic allocation, records, and
linked lists. They are very powerful tools that can be used
to great advantage but are quite often overlooked by many
Pascal programmers that I have talked to. These are the
tools that give Pascal and Modula-2 an advantage in
flexibility over such languages as BASIC and FORTRAN. They
do require a bit of deep concentration to understand, but
you will be greatly rewarded if you take the time to
understand and use them.
MODULA-2 TUTORIAL - PART III
Part III of this tutorial covers those aspects of
Modula-2 that are not included in Pascal in any way. Some of
the topics are independent compilation, the entire topic of
modules, and concurrent processing. These are advanced
topics and some of these topics may be the reasons that you
selected Modula-2 as a programming language. The material
covered in Part I in conjunction with that covered in Part
III can lead to some very powerful programming techniques.
Page 1
Introduction to the Modula-2 Tutorial
To efficiently use this tutorial, you must carefully
study all of the material in Part I, then you can do a lot
of jumping around in Parts II and III and still cover the
material in a meaningful manner. You may also choose to
only study some chapters of the last two parts in order to
learn the needed material for the programming problem at
hand. I would like to emphasize that it is important that
you cover the material in Part I very carefully and in order
since so much depends on what was taught before. When you
get to the last two parts, comments at the beginning of each
chapter will tell you what parts need to be reviewed in
order to effectively use the material in the chapter.
FOR THE BEGINNING PROGRAMMER
If you are a novice to computer programming, this
course is for you because it is assumed that you know
nothing about programming. Many sections, especially in the
early chapters, will cover very basic topics for your
benefit. The biggest problem you will have will be setting
up your compiler for use, since this can be a very difficult
task. Possibly you know someone with experience that would
be willing to help you get started.
FOR ALL PROGRAMMERS
There are, at this time, a very limited number of
Modula-2 compilers available, but it would not be possible
to include notes on every compiler about how to install it
for your computer. The COMPILER.DOC file on your
distribution disk contains notes on all of the compilers we
have had access to and some of the difficulties in setting
them up for the IBM-PC or near compatibles. In addition,
all compilers do not implement all functions defined in
Niklaus Wirth's definition of the language. As many of
these as we have found are listed in the same file.
Finally, all of the problems in compiling the files on this
disk are noted in the COMPILER.DOC file. It would be worth
your effort to print out this file and keep the hardcopy
handy while you are working your way through the lessons.
Modula-2, as defined by Niklaus Wirth, contains no
provisions for input or output because they are so hardware
dependent. It is up to each compiler writer to provide you
with supplemental procedures for handling I/O (input/output)
and a few other machine dependent features. Niklaus Wirth
did recommend a library of I/O routines that should be
available and most compilers contain at least those
facilities, and usually provide many more. The COMPILER.DOC
file will contain notes about differences in these
facilities for those compilers which we have access to. The
Page 2
Introduction to the Modula-2 Tutorial
COMPILER.DOC file will be updated anytime new information is
available.
SIMPLE EXAMPLES WILL BE USED
All of the instructional programs are purposely kept
simple and small to illustrate the point intended. It is of
little value to you to present you with a large complex
program to illustrate what can be illustrated in a small
program better. In addition, every program is complete, and
can be compiled and run. Program fragments frequently pose
as many questions as they answer.
Because it would be a disservice to you to teach you a
lot of simple techniques and never show you how they go
together in a significant program, chapters 9 and 16 contain
several larger example programs. A relatively small amount
of description is given about these programs because you
will have already covered the details and only need a quick
overview of how to put the various constructs together. You
will find some of these programs useful and will have the
ability to modify and enhance them for your use since you
have the source code.
SOME VARIABLE NAMES SEEM SILLY, WHY IS THAT?
I have seen example programs with the same name
everywhere, and had a hard time deciding what names were
required and what could be changed to something more
meaningful. For example a "SORT" program is in a file named
"SORT", the program name is "SORT", the input file is named
"SORT", and variables were named "SORT1", SORT2", etc. This
was no help to myself, a novice sorter, and would be no help
to you. For that reason the first program is in a file
named "PUPPYDOG.MOD" and the module name is "PuppyDog". It
should be obvious to even the newest programmer that the
name of a module can be anything if it is allowed to be
"PuppyDog". You will learn later that well selected names
can be a great aid in understanding a program. This will be
evident in some of the early programs when variable names
are chosen to indicate what type of variable they are.
Some compilers require that the module name be the same
as the file name, and all require them to agree when you get
to global modules because of the way "Type checking" is
accomplished. It would be best for you to get into the
habit of naming them both the same now. For that reason,
all of the example programs use the same name for the file
name and for the module name. Your compiler may allow you
to use different names. It will be left up to you to study
your manual and see if this is so for your compiler.
Page 3
Introduction to the Modula-2 Tutorial
WHAT IS A COMPILER?
There are two primary methods used in running any
computer program that is written in a readable form of
English. The first method is an interpreter. An
interpreter is a program that looks at each line of the
"english" program, decides what the "english" on that line
means, and does what it says to do. If one of the lines is
executed repeatedly, it must be scanned and analyzed each
time, greatly slowing down the solution of the problem at
hand.
A compiler on the other hand, is a program that looks
at each statement one time and converts it into a code that
the computer understands directly. When the compiled
program is actually run, the computer does not have to
figure out what each statement means, it is already in a
form the computer can run directly, hence a much faster
execution of the program. Due to the nature of Modula-2,
there will be few, if any, interpreters.
WHAT ABOUT THE PROGRAMMING EXERCISES?
The programming exercises at the end of each chapter
are a very important part of the tutorial. If you do them,
you will embed the principles taught in each chapter more
firmly in your mind than if you ignore them. If you choose
to ignore them, you will be somewhat adept at reading
Modula-2 programs but very ineffectual at writing them. By
doing the exercises, you will also gain considerable
experience in using your editor and compiler.
It will be assumed that you know how to use your
compiler and that you have some kind of an editor for use
with the example files. With the above in mind, you are now
ready to begin your tour of Modula-2.
A sample program is included in this chapter for you to
try with your compiler. It is left as an exercise for you
to compile and run FIRSTEX.MOD. When you can successfully
compile and run this program, you are ready to begin the
tutorial on Modula-2 programming. Do not worry about what
the statements mean in FIRSTEX.MOD, you will have a complete
understanding of this program by the time you complete
chapter 4.
Page 4